START Magazine/START VOL 3 NO 12.st/BABEL.ARC/BABEL.BAS

BASIC Source File | 1989-04-12 | 12.6 KB | 458 lines

REM Program Babel
REM by Jim Pierson-Perry
REM Copright 1989 Antic Publishing
REM
REM
REM Babel is a sound file conversion program. It accepts sound
REM files created by Replay4, Digisound, Navarone/Hippo ST Sound
REM Designer, Macintosh SoundCap/SoundMaster, Amiga IFF and Mac/ST
REM versions of Sound Designer. Output sound files can be written
REM in Replay4, Digisound or Navarone/Hippo formats.
REM
REM Program functions are load a sound file, play the sound (audition)
REM through monitor speaker or Replay4/Digisound cartridge, adjust replay
REM rate and save sound file in one of the three supported formats. A demo
REM of sound creation via pure math is provided using the Karplus-Strong
REM string synthesis algorithm.
REM
REM This program was coded using Hisoft BASIC Professional using the
REM Replay4 binary file extension to the Hisoft compiler library (comes
REM with the Replay4 program disk from MichTron). All screen
REM resolutions are supported.
REM
REM *************************************************************************
REM
REM Start with definitions and variable initializations.
REM Force all variable to default to 2-byte integer words
REM
defint a-z
REM
REM Compiler needs to pull routines from the Hisoft library.
REM GEMAES and GEMDOS come with Hisoft. The REPLAY library
REM came from the Replay4 program disk and was added into the
REM Hisoft compiler library using its BUILDLIB.TTP program.
REM
library "gemaes","gemdos","replay"
dim mess(7),nav_rates(7)
REM
REM Use constants as reference points for menu items in the
REM working subroutines. If the menu is changed later, only these
REM constants need to change (rather than each reference within
REM the program)
REM
const m_about=9,m_load=18,m_save=19,m_shift=21,m_quit=25,m_audition=23,m_form=40
const m_rate5=27,m_audio=36,m_ks=20,mask=255,mu_mesag=16,mn_selected=10
rrate=4
audio_out=0
save_format=0
data 5000,7500,10000,15000,20000,31000,31000,31000
for i=0 to 7
read nav_rates&(i)
next i
sample$=chr$(rrate)
nsamp&=0
valid_sample=0
REM
REM Build the program menu
REM
menu$="[ Desk |  About Babel ]"
menu$=menu$+"[ File |  Load Sample \  Save Sample \  String Synth \  Shift Base \(---------------\  Audition \(---------------\  Quit ]"
menu$=menu$+"[ Rate |   5   \   7.5 \  10   \  15   \  20   \  31   \  40   \  50   ]"
menu$=menu$+"[ Audio |  Monitor Speaker \  Replay Cartridge \(-------------------\  Save Format... \"
menu$=menu$+"     ...Replay4 \     ...Digisound \     ...Navarone ]"
REM
REM Activate the menu, disable desk accessories and set defaults
REM for replay rate and audio output
REM
m_pointer&=FNmenu&(menu$)
for i=m_about+2 to m_about+7
    menu_ienable m_pointer&,i,0
next i
menu_icheck m_pointer&,m_rate5+rrate,1
menu_icheck m_pointer&,m_audio,1
menu_icheck m_pointer&,m_form,1
menu_ienable m_pointer&,m_rate5+6,0
menu_ienable m_pointer&,m_rate5+7,0
REM
REM Main program loop. It cycles here looking for action on the menu
REM bar. FNevnt_multi used to make it easy to add ST keyboard command
REM equivalents for menu actions in a subsequent version
REM
do
    e=FNevnt_multi(mu_mesag,0,0,0,0,0,0,0,0,0,0,0,0,0,varptr(mess(0)),0,0,0,0,0,k,0)
    if e and mu_mesag then do_menu mess(0)
loop
REM
REM Main subroutine for determining what program action to take as
REM a result of triggering the menu bar
REM
sub do_menu(VAL mes_type)
    shared mess(1),m_pointer&
    static title,item
    if mes_type=mn_selected then
        title=mess(3)
        item=mess(4)
        select case item
            case m_about: call do_about
            case m_load: call do_load
            case m_save: call do_save
            case m_ks: call do_ks
            case m_shift: call do_shift
            case m_audition: call do_audition
            case m_quit: stop -1
            case m_rate5 to m_rate5+7: do_rates item
            case m_audio to m_audio+1: do_audio item
            case m_form to m_form+2: do_format item
        end select
        menu_tnormal m_pointer&,title,1
    end if
end sub
REM
REM Display info box
REM
sub do_about
    static dummy
    dummy=FNform_alert(1,"[0][   Babel |  | by Jim Pierson-Perry | Copyright 1989 Antic Publishing ][ OK ! ]")
end sub
REM
REM Adjust the replay rate. Turn off the check on the old menu
REM item, change the rate and indicate new setting on the menu
REM
sub do_rates(m)
    shared rrate,m_pointer&,audio_out,sample$
    static curr_rate
    if (audio_out=1) or ((m<m_rate5+6) and audio_out=0) then
        menu_icheck m_pointer&,m_rate5+curr_rate+4,0
        curr_rate=m-m_rate5-4
        rrate=m-m_rate5
        menu_icheck m_pointer&,m,1
        mid$(sample$,1,1)=chr$(rrate)
    end if
end sub
REM
REM Set the audio output destination - monitor speaker or through
REM the Replay4/Digisound cartridge to an external speaker
REM
sub do_audio(m)
    shared m_pointer&,audio_out
    static curr_audio
    menu_icheck m_pointer&,curr_audio+m_audio,0
    curr_audio=m-m_audio
    audio_out=curr_audio
    menu_icheck m_pointer&,m,1
    menu_ienable m_pointer&,m_rate5+6,m-m_audio
    menu_ienable m_pointer&,m_rate5+7,m-m_audio
end sub
REM
REM Play the sample data currently in memory using the Replay4
REM library functions extensions to Hisoft BASIC. The valid_sample
REM flag ensures a sample has been loaded so you can't play
REM "empty memory"
REM
sub do_audition
    shared sample$,rrate,audio_out,valid_sample,nsamp&
    if valid_sample=1 then
        hifi audio_out
        frequency rrate
        replay sadd(sample$),nsamp&,0
    end if
end sub
REM
REM Subroutine to set the type of file format to use when saving
REM sample data files to disk. The current choice is updated on
REM the menu bar
REM
sub do_format(m)
    shared m_pointer&,save_format
    static curr_format
    menu_icheck m_pointer&,curr_format+m_form,0
    curr_format=m-m_form
    save_format=curr_format
    menu_icheck m_pointer&,m,1
end sub
REM
REM Subroutine to synthesize a string sample
REM from random numbers (Karplus-Strong algorithm).
REM This is an ST adaptation of the procedure
REM given in Electronic Musician (12/1987)
REM which, in turn, came from an earlier article
REM in Polyphony magazine (12/1984).
REM It is provided as an example of creating
REM a realistic sound from pure math.
REM
sub do_ks
    shared nsamp&,rrate,valid_sample,sample$
    static np,d,l,m,samp_val,i&
    np=64
    d=FNform_alert(0,"[0][   Karplus-Strong |String Synthesis Demo |  |Select Wavetable Size ][ 256 | 128 | 64 ]")
    d=512/(2^d)
    dim rn_table(d)
    mouse 2
    randomize int(timer)
    for l=1 to d
        rn_table(l)=int(rnd(l)*d)
    next l
    nsamp&=clng(np*d)
    sample$=chr$(rrate)+string$(nsamp&,128)
    i&=sadd(sample$)+1&
    for l=1 to np
        for m=2 to d
            samp_val=(rn_table(m)+rn_table(m-1))/2
            rn_table(m-1)=samp_val
            pokeb i&,samp_val
            incr i&
        next m
        samp_val=(rn_table(1)+rn_table(d))/2
        rn_table(d)=samp_val
        pokeb i&,samp_val
        incr i&
    next l
    mouse 0
    erase rn_table
    valid_sample=1
end sub
REM
REM Routine to switch sound file in memory between signed and
REM unsigned integer bases. Needed at minimum by an Amiga sound
REM file type (not IFF) with headerless file structure, like
REM Replay4, but uses signed integer base so it must be adjusted.
REM
sub do_shift
    shared sample$,nsamp&,valid_sample
    static i&,j&,d
    if valid_sample>0 then
        mouse 2
        i&=sadd(sample$)+1&
        j&=i&+nsamp&-1&
        do
            d=(peekb(i&)+128) and mask
            pokeb i&,d
            incr i&
        loop until i&>j&
        mouse 0
    end if
end sub
REM
REM Save the current sample data file from memory to disk using
REM the currently active save format. The sample in memory is
REM stored in Replay4 format to be compatible with the playback
REM driver used by the audition menu command
REM
sub do_save
    shared sample$,save_format,rrate,nsamp&,nav_rates()
    static fout$,i&,j&,d,ext$
    ext$="SPL"
    if save_format>0 then ext$="SND"
    fout$=FNselect_file$(ext$)
    if fout$="" then exit sub
    open fout$ for output as #1
    mouse 2
    REM
    REM Convert from unsigned to signed integers for Digisound
    REM and Navarone file formats
    REM
    if save_format>0 then
        i&=sadd(sample$)+1&
        j&=i&+nsamp&-1&
        do
            d=(peekb(i&)-128) and mask
            pokeb i&,d
            incr i&
        loop until i&>j&
    end if
    REM
    REM Write the sample with the appropriate header information
    REM
    select case save_format
        case 0
            print #1,mid$(sample$,1&,nsamp&+1&)
        case 1
            print #1,"GP"+mkl$(nsamp&)+chr$(abs(rrate-7))+mid$(sample$,1&,nsamp&+1&)+string$(640,128)+string$(8,0)
        case 2
            print #1,mkl$(nsamp&)+mki$(nav_rates(rrate))+mid$(sample$,2&,nsamp&)
    end select
    close #1
    mouse 0
end sub
REM
REM Subroutine to get a sample data file from disk. It uses internal
REM pattern recognition to determine the incoming file type (e.g. a
REM known header formulation or file length). The default file type
REM is Replay4 as it has no header or anything but the sample data bytes
REM
sub do_load
    shared sample$,valid_sample,nsamp&,rrate
    static i&,j&,k&,flen&,fin$,sbffr$,stype,s_start&,d,m,e
    fin$=FNselect_file$("*")
    if fin$="" then exit sub
    mouse 2
    open fin$ for input as #1
    flen&=lof(1)
    sbffr$=input$(flen&,1)
    close #1
    sample$=chr$(rrate)
    stype=0
    s_start&=1
    nsamp&=flen&
    REM
    REM This section was put in for a particular type of input file
    REM that I use, but is probably not of much interest to others
    REM It recognizes data files from the IBM MIDIUM sample editor
    REM for the Mirage sampler. These have no identifying header but
    REM are always of a set file length.
    REM
    if flen&=66161& then
        d=FNform_alert(1,"[2][ | | Is this a MIDIUM data file ][ Yes | No ]")
        if d=1 then
            stype=6
            s_start&=626
            nsamp&=65536&
        end if
    end if
    REM
    REM Digisound file import
    REM
    if mid$(sbffr$,1,2)="GP" then
        stype=1
        s_start&=9
        nsamp&=cvl(mid$(sbffr$,3,4))
    end if
    REM
    REM Mac SoundCap/SoundMaster file import
    REM
    if mid$(sbffr$,66,7)="FSSDSFX" then
        stype=4
        s_start&=129
        nsamp&=flen&-128&
    end if
    REM
    REM Sound Designer (Mac, without the 128 MacBinary header,
    REM  or ST) file import
    REM
    if cvi(mid$(sbffr$,1,2))=1336 then
        stype=5
        s_start&=1337
        nsamp&=cvl(mid$(sbffr$,185,4))/2&
    end if
    REM
    REM ST Sound Digitizer (Navarone/Hippo)file import
    REM
    if cvl(mid$(sbffr$,1,4))=flen&-6& then
        stype=2
        s_start&=7
        nsamp&=flen&-6&
    end if
    REM
    REM Amiga IFF file import
    REM
    if mid$(sbffr$,1,4)="FORM" then
        stype=3
        s_start&=instr(sbffr$,"BODY")+8&
        nsamp&=cvl(mid$(sbffr$,s_start&-4&,4))
    end if
    select case stype
        case 0
            sample$=sample$+mid$(sbffr$,s_start&,flen&)
        REM
        REM Convert some files from signed integers to unsigned
        REM integers (used by Replay4)
        REM
        case 1 to 3
            sample$=sample$+mid$(sbffr$,s_start&,flen&)
            i&=sadd(sample$)+1&
            j&=i&+nsamp&-1&
            do
                d=(peekb(i&)+128) and mask
                pokeb i&,d
                incr i&
            loop until i&>j&
        case 4
            sample$=sample$+string$(flen&,128)
            i&=sadd(sbffr$)+s_start&-1&
            j&=sadd(sample$)+1&
            d=1
            REM Mac and Amiga.IFF need to have the sample rate
            REM taken down by a factor of 10/11 to compensate
            REM for basic differences in sampling rates supported
            REM by the machines
            REM
            for k&=s_start& to flen&
                pokeb j&,peekb(i&)
                incr i&
                incr j&
                incr d
                if d=6 then
                    incr i&
                    d=1
                    nsamp&=nsamp&-1&
                end if
            next k&
        case 5
            sample$=sample$+string$(nsamp&,128)
            i&=sadd(sbffr$)+1336&
            j&=sadd(sample$)+1&
            k&=i&+flen&-1
            REM
            REM Sound Designer files must be converted from signed
            REM to unsigned integers. In addition, they have to be
            REM taken from 16 bit resolution down to 8 bit resolution
            REM
            do
                d=(peekb(i&)+128) and mask
                pokeb j&,d
                incr i&
                incr i&
                incr j&
            loop until i&>k&
        case 6
            sample$=sample$+mid$(sbffr$,s_start&,flen&)
            i&=sadd(sample$)+1&
            j&=i&+nsamp&
            REM
            REM The MIDIUM files are particularly warped. Each byte
            REM must have the high and low nybbles reversed
            REM
            while i&<j&
                e=peekb(i&)
                d=e and 15
                m=e and 240
                pokeb i&,16%*d+m/16%
                incr i&
            wend
    end select
    valid_sample=1
    mouse 0
end sub
REM
REM General routine to obtain file/path name from the GEM file
REM selector box. This was taken almost verbatim from the Hisoft
REM BASIC example disk. I added the ext$ parameter and detection
REM of Cancel button by a null file name
REM
DEF FNselect_file$(ext$)
    static path$,name$,drv$,where,but
    path$=space$(64)
    drv$=chr$(FNdgetdrv+"A"%)
    dgetpath sadd(path$),0
    if left$(path$,1)=chr$(0) then
        path$=drv$+":\*."+ext$
    else
        path$=drv$+":"+path$
        where=instr(path$,chr$(0))
        path$=left$(path$,where-1)
        path$=path$+"\*."+ext$
    end if
    fsel_input path$,name$,but
    cls
    if but=0 then
        FNselect_file$=""
        exit def
    end if
    where=instr(path$,"*")
    path$=left$(path$,where-1)
    FNselect_file$=path$+name$
end def